Fine-Grained Complexity of Safety Verification

We study the fine-grained complexity of Leader Contributor Reachability (LCR) and Bounded-Stage Reachability (BSR), two variants of the safety verification problem for shared memory concurrent programs. For both problems, the memory is a single variable over a finite data domain. We contribute new verification algorithms and lower bounds based on the Exponential Time Hypothesis (ETH) and kernels. LCR is the question whether a designated leader thread can reach an unsafe state when interacting with a certain number of equal contributor threads. We suggest two parameterizations: (1) By the size of the data domain D and the size of the leader L, and (2) by the size of the contributors C. We present two algorithms, running in O∗((L ·(D+1))L·D ·DD) and O(4) time, showing that both parameterizations are fixed-parameter tractable. Further, we suggest a modification of the first algorithm, suitable for practical instances. The upper bounds are complemented by (matching) lower bounds based on ETH and kernels. For BSR, we consider programs involving t different threads. We restrict to computations where the write permission changes s times between the threads. BSR asks whether a given configuration is reachable via such a s-stage computation. When parameterized by P, the maximum size of a thread, and t, the interesting observation is that the problem has a large number of difficult instances. Formally, we show that there is no polynomial kernel, no compression algorithm that reduces D or s to a polynomial dependence on P and t. This indicates that symbolic methods may be harder to find for this problem.